package com.erp.erp_ui.basic.controller;

import com.alibaba.fastjson.JSONObject;
import com.erp.erp_entitys.warehouse.req.ProductInfoReq;
import com.erp.erp_entitys.warehouse.rsp.ProductInfoRsp;
import com.erp.erp_ui.base.Base;
import com.erp.erp_ui.basic.req.AddDictionaryReq;
import com.erp.erp_ui.basic.service.ProductService;
import com.erp.erp_ui.basic.vo.DictionaryCategoryVo;
import com.erp.erp_ui.basic.vo.DictionaryPageListVo;
import com.erp.utils.R;
import com.erp.utils.ResultStatusEnum;
import com.github.pagehelper.PageInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @ClassName : ProductController
 * @Description : 产品控制层
 * @Author : lst
 * @Date: 2021-09-14 00:10
 */
@Controller
@RequestMapping(value = "product")
public class ProductController extends Base {

    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(ProductController.class);

    /**
     * 业务逻辑接口
     */
    private final ProductService productService;

    @Autowired
    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    /**
     * 获取分页列表
     * @param lx 小类
     * @param name 名称
     * @return 分页列表
     */
    @GetMapping("/getDictionaryListByPage")
    @ResponseBody
    public R getDictionaryListByPage(Integer lx, String name) {
        try {
            LOGGER.info("基础资料-产品中心-获取分页列表 lx=" + lx + ",name=" + name);
            PageInfo<DictionaryPageListVo> pageInfo = productService.getDictionaryListByPage(lx, name);
            return R.build(0, "", pageInfo.getTotal(), pageInfo.getList());
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取分页列表异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取最新字典编码
     * @param lx 小类
     * @return 最新字典编码
     */
    @GetMapping("/getNewDictionaryCode")
    @ResponseBody
    public R getNewDictionaryCode(Integer lx) {
        try {
            LOGGER.info("基础资料-产品中心-获取最新字典编码：lx = " + lx);
            String code = productService.getNewDictionaryCode(lx);
            return R.build(code);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取最新字典编码异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 品类新增、修改
     *
     * @param req 品类新增、修改入参
     * @return 品类新增、修改结果
     */
    @PostMapping("/category/add")
    @ResponseBody
    public R add(@Validated @RequestBody AddDictionaryReq req) {
        try {
            LOGGER.info("基础资料-产品中心-品类新增、修改 req=" + req.toString());
            return productService.addCategory(req);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-品类新增、修改异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 品类批量删除
     *
     * @param ids 删除的品类id集合
     * @return 删除结果
     */
    @GetMapping("/category/batchDelete")
    @ResponseBody
    public R batchDelete(String ids) {
        try {
            LOGGER.info("基础资料-产品中心-品类批量删除 ids=" + ids);
            productService.categoryBatchDelete(ids);
            return R.build("");
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-品类批量删除异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取模具字典信息
     * @return 模具字典信息
     */
    @GetMapping("/category/getDictionaryCategory")
    @ResponseBody
    public R getDictionaryCategory() {
        try {
            LOGGER.info("基础资料-产品中心-获取模具字典信息");
            DictionaryCategoryVo vo = productService.getDictionaryCategory();
            return R.build(vo);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取模具字典信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取模具字典包材信息
     * @return 模具字典包材信息
     */
    @GetMapping("/category/getDictionaryPackingMaterialCategory")
    @ResponseBody
    public R getDictionaryPackingMaterialCategory() {
        try {
            LOGGER.info("基础资料-产品中心-获取模具字典信息");
            DictionaryCategoryVo vo = productService.getDictionaryPackingMaterialCategory();
            return R.build(vo);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取模具字典信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取模具字典配件信息
     * @return 模具字典配件信息
     */
    @GetMapping("/category/getDictionaryPartsCategory")
    @ResponseBody
    public R getDictionaryPartsCategory() {
        try {
            LOGGER.info("基础资料-产品中心-获取模具字典配件信息");
            DictionaryCategoryVo vo = productService.getDictionaryPartsCategory();
            return R.build(vo);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取模具字典配件信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取配件模具字典信息
     * @return 配件模具字典信息
     */
    @GetMapping("/category/getPartsDictionaryCategory")
    @ResponseBody
    public R getPartsDictionaryCategory() {
        try {
            LOGGER.info("基础资料-产品中心-获取配件模具字典信息");
            DictionaryCategoryVo vo = productService.getPartsDictionaryCategory();
            return R.build(vo);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-获取配件模具字典信息异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取规格配件信息
     * @param req 查询条件
     * @return 规格配件信息
     */
    @GetMapping("/getSpecPartsInfoByConcat")
    @ResponseBody
    public R getSpecPartsInfoByConcat(ProductInfoReq req){
        try {
            LOGGER.info("基础资料-产品中心-获取规格配件信息 req =" + req.toString());
            List<ProductInfoRsp> specParts = productService.getSpecPartsInfoByConcat(req);
            return R.build(specParts);
        }catch (Exception e){
            LOGGER.info("基础资料-产品中心-获取规格配件信息异常：" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取规格配件信息
     * @param req 查询条件
     * @return 规格配件信息
     */
    @GetMapping("/getSpecPartsInfo")
    @ResponseBody
    public R getSpecPartsInfo(ProductInfoReq req){
        try {
            LOGGER.info("基础资料-产品中心-获取规格配件信息 req =" + req.toString());
            List<ProductInfoRsp> specParts = productService.getSpecPartsInfo(req);
            return R.build(specParts);
        }catch (Exception e){
            LOGGER.info("基础资料-产品中心-获取规格配件信息异常：" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 获取产品信息
     * @param req 查询条件
     * @return 产品信息
     */
    @GetMapping("/getProductInfoByConcat")
    @ResponseBody
    public R getProductInfoByConcat(ProductInfoReq req){
        try {
            LOGGER.info("基础资料-产品中心-获取产品信息 req =" + req.toString());
            List<ProductInfoRsp> specParts = productService.getProductInfoByConcat(req);
            return R.build(specParts);
        }catch (Exception e){
            LOGGER.info("基础资料-产品中心-获取产品信息异常：" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }

    /**
     * 字典列表-导出
     *
     * @param lx 字典小类
     * @return 字典列表-导出
     */
    @GetMapping(value = "export/productDictionaryExport")
    @ResponseBody
    public R productDictionaryExport(Integer lx) {
        try {
            LOGGER.info("基础资料-产品中心-字典列表-导出: lx=" + lx);
            JSONObject obj = productService.productDictionaryExport(lx);
            return R.build(obj);
        } catch (Exception e) {
            LOGGER.info("基础资料-产品中心-字典列表-导出异常:" + e);
            return R.buildError(ResultStatusEnum.SYSTEM_ERROR);
        }
    }
}
